package org.electronic.registration.factory;

import flex.messaging.FactoryInstance;
import flex.messaging.FlexFactory;
import flex.messaging.config.ConfigMap;
import flex.messaging.services.ServiceException;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;
import org.springframework.web.context.support.WebApplicationContextUtils;

/**
 * This interface is implemented by factory components which provide
 * <p/>
 * instances to the flex messaging framework. To configure flex data services
 * <p/>
 * to use this factory, add the following lines to your services-config.xml
 * <p/>
 * file (located in the WEB-INF/flex directory of your web application).
 * <p/>
 * <p/>
 * <p/>
 * &lt;factories&gt;
 * <p/>
 * &lt;factory id="spring" class="flex.samples.factories.SpringFactory" /&gt;
 * <p/>
 * &lt;/factories&gt;
 * <p/>
 * <p/>
 * <p/>
 * You also must configure the web application to use spring and must copy the
 * spring.jar
 * <p/>
 * file into your WEB-INF/lib directory. To configure your app server to use
 * spring,
 * <p/>
 * you add the following lines to your WEB-INF/web.xml file:
 * <p/>
 * <p/>
 * <p/>
 * &lt;context-param&gt;
 * <p/>
 * &lt;param-name&gt;contextConfigLocation&lt;/param-name&gt;
 * <p/>
 * &lt;param-value&gt;/WEB-INF/applicationContext.xml&lt;/param-value&gt;
 * <p/>
 * &lt;/context-param&gt;
 * <p/>
 * <p/>
 * <p/>
 * &lt;listener&gt;
 * <p/>
 * &lt;listener-class&gt;org.springframework.web.context.ContextLoaderListener&lt;/listener-class&gt;
 * <p/>
 * &lt;/listener&gt;
 * <p/>
 * <p/>
 * <p/>
 * Then you put your spring bean configuration in WEB-INF/applicationContext.xml
 * (as per the
 * <p/>
 * line above). For example:
 * <p/>
 * <p/>
 * <p/>
 * &lt;?xml version="1.0" encoding="UTF-8"?&gt;
 * <p/>
 * &lt;!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
 * "http://www.springframework.org/dtd/spring-beans.dtd"&gt;
 * <p/>
 * <p/>
 * <p/>
 * &lt;beans&gt;
 * <p/>
 * &lt;bean name="weatherBean" class="dev.weather.WeatherService"
 * singleton="true"/&gt;
 * <p/>
 * &lt;/beans&gt;
 * <p/>
 * <p/>
 * <p/>
 * Now you are ready to define a destination in flex that maps to this existing
 * service.
 * <p/>
 * To do this you'd add this to your WEB-INF/flex/remoting-config.xml:
 * <p/>
 * <p/>
 * <p/>
 * &lt;destination id="WeatherService"&gt;
 * <p/>
 * &lt;properties&gt;
 * <p/>
 * &lt;factory&gt;spring&lt;/factory&gt;
 * <p/>
 * &lt;source&gt;weatherBean&lt;/source&gt;
 * <p/>
 * &lt;/properties&gt;
 * <p/>
 * &lt;/destination&gt;
 *
 * @author Jeff Vroom
 */

@Service
public class SpringFactory implements FlexFactory {

    private static final String SOURCE = "source";

    /**
     * This method can be used to initialize the factory itself. It is called
     * with configuration
     * <p/>
     * parameters from the factory tag which defines the id of the factory.
     */

    public void initialize(String id, ConfigMap configMap) {
    }

    /**
     * This method is called when we initialize the definition of an instance
     * <p/>
     * which will be looked up by this factory. It should validate that
     * <p/>
     * the properties supplied are valid to define an instance.
     * <p/>
     * Any valid properties used for this configuration must be accessed to
     * <p/>
     * avoid warnings about unused configuration elements. If your factory
     * <p/>
     * is only used for application scoped components, this method can simply
     * <p/>
     * return a factory instance which delegates the creation of the component
     * <p/>
     * to the FactoryInstance's lookup method.
     */
    public FactoryInstance createFactoryInstance(String id, ConfigMap properties) {
        SpringFactoryInstance instance = new SpringFactoryInstance(this, id,
                properties);
        instance.setSource(properties.getPropertyAsString(SOURCE, instance
                .getId()));
        return instance;
    } // end method createFactoryInstance()

    /**
     * Returns the instance specified by the source
     * <p/>
     * and properties arguments. For the factory, this may mean
     * <p/>
     * constructing a new instance, optionally registering it in some other
     * <p/>
     * name space such as the session or JNDI, and then returning it
     * <p/>
     * or it may mean creating a new instance and returning it.
     * <p/>
     * This method is called for each request to operate on the
     * <p/>
     * given item by the system so it should be relatively efficient.
     * <p/>
     * <p/>
     * <p/>
     * If your factory does not support the scope property, it
     * <p/>
     * report an error if scope is supplied in the properties
     * <p/>
     * for this instance.
     */
    public Object lookup(FactoryInstance inst) {
        SpringFactoryInstance factoryInstance = (SpringFactoryInstance) inst;
        return factoryInstance.lookup();
    }

    static class SpringFactoryInstance extends FactoryInstance {
        SpringFactoryInstance(SpringFactory factory, String id,
                              ConfigMap properties) {
            super(factory, id, properties);
        }

        public String toString() {
            return "SpringFactory instance for id=" + getId() + " source="
                    + getSource() + " scope=" + getScope();
        }

        public Object lookup() {
            ApplicationContext appContext = WebApplicationContextUtils
                    .getWebApplicationContext(flex.messaging.FlexContext
                            .getServletConfig().getServletContext());

            String beanName = getSource();
            try {
                return appContext.getBean(beanName);
            } catch (NoSuchBeanDefinitionException nexc) {
                ServiceException e = new ServiceException();
                String msg = "Spring service named '" + beanName
                        + "' does not exist.";
                e.setMessage(msg);
                e.setRootCause(nexc);
                e.setDetails(msg);
                e.setCode("Server.Processing");

                throw e;
            } catch (BeansException bexc) {
                ServiceException e = new ServiceException();
                String msg = "Unable to create Spring service named '"
                        + beanName + "' ";
                e.setMessage(msg);
                e.setRootCause(bexc);
                e.setDetails(msg);
                e.setCode("Server.Processing");
                throw e;
            }
        }
    }
}
